Exemplary embodiments of the present invention relate to mashup software applications, and more particularly, to the assembly of different widgets to produce mashup software applications.
Service-oriented computing supports the notion of aggregating any number of modular, atomic software capabilities discoverable and usable by disparate organizations. For example, a mashup is a software application rendered in a browser that combines data and functionality from multiple distinct sources into a single, integrated tool providing a common view (for example, Web 2.0 applications). To support the creation of mashups, reusable widgets (or mashup components), which combine on-line data resources with server-side APIs and user interface functionalities in a compact package that can easily be re-used in other applications, have emerged. Widgets, which can also be combined together and published as new application components, provide atomic elements of mashup application functionality, and thereby can enable easy on the glass integration of otherwise very complicated or costly features to virtually any application. For example, mashups can be implemented to extend enterprise data with service components from the public internet such as Google Maps for location services, RSS (Really Simple Syndication) Feeds to publish content, or Widgets (web plug-ins) that provide specific functions such as blog, wiki, or social networking capabilities.
Generally, mashups are not intended to be strategic, systematically built, industrial-strength enterprise applications; rather, they are created quickly or opportunistically to meet a focused tactical need. Mashups are generally personalized to fulfill personal productivity needs rather than the requirements of a long-standing corporate role. Mashups leverage content and logic from other Web sites and Web applications, are lightweight in implementation, and are implemented using with a minimal amount of code (which can be, for example, client-side JavaScript™ or server-side scripting languages, such as PHP or Python).
Widgets exchange data using input and output properties. Each property is defined by a type and each type is associated with a data type. To participate in a mashup, each widget publishes the properties that it accepts as input and provides as output. More particularly, inter-widget communication in a mashup is achieved by “wiring” output properties of source widgets to input properties of target widgets, and a property broker manages the interactions between the widgets. Thus, interaction between widgets in mashups is loosely coupled. When the value of a property changes in the source widget, the target widget reacts to that change by executing the action to which the property is wired. The wiring interface allows developers to configure connections, or wires, between cooperative, heterogeneous widgets based on the input and output properties of the widgets to form more complex widgets or applications.
The loose coupling of coarse-grained widgets is a cornerstone of the mashup architecture. It enables diverse groups in different locations to leverage each other's efforts and to interoperate with each other. Each group needs to understand only the input and output properties for a widget and not the internal logic. Nevertheless, the use of communication between widgets in terms of data sent from output properties to input properties along a wire does not currently allow for widgets to be completely decoupled. In particular, wires presently cannot be formed in mashups unless both endpoints use the same data type. For example, two widgets may utilize the concept of a date, but unless the dates are identically defined (namespace, name, type), they cannot be connected.